/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package se_juegos;

import Inference.Configuracion;
import Inference.Constants;
import Inference.Engine;
import Inference.OntologyAccess;
import com.hp.hpl.jena.rdf.model.InfModel;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.ResourceFactory ;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.reasoner.rulesys.GenericRuleReasoner;
import com.hp.hpl.jena.reasoner.rulesys.RETERuleInfGraph;
import com.hp.hpl.jena.reasoner.rulesys.Rule;
import com.hp.hpl.jena.vocabulary.ReasonerVocabulary;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;
import javax.swing.JOptionPane;

/**
 *
 * @author Adrian, Fernando
 */

public class SE_juegos {

    
    /** 
     * @param args the command line arguments
     */
    
    public static BufferedReader br;
    public static String rutaOntologia = "";
    public static String rutaReglas = "";
    public static String urlspace = "http://www.semanticweb.org/adrian/ontologies/2014/3/untitled-ontology-4#";
    public static String[] archivos;
    public static int numArchivos=6;
    public static Engine motor = null;
    
    public static void main(String[] args) throws IOException, Exception{
        // TODO code application logic here
        
        br = new BufferedReader(new InputStreamReader(System.in));
        Model m= ModelFactory.createDefaultModel();
        
        String opcion="";
        
        while (!opcion.equalsIgnoreCase("salir")){
            
            
            /*if (opcion.equalsIgnoreCase("ontologia") || opcion.equalsIgnoreCase("") ){
            
                leeOntologia(m,null);
            }
            
            if (opcion.equalsIgnoreCase("reglas") || opcion.equalsIgnoreCase("")){

                leeReglasCorrer(m,null);
            }
            
            if (opcion.equalsIgnoreCase("run")){
                correr(m);                
            }
            
            if (opcion.equalsIgnoreCase("juego")){                
                
                agregarStatement("nuevoJuego", "NombreJuego", "NuevoNombrejuego", m);                
                
            }
            */
            if (opcion.equalsIgnoreCase("imprimir")){                
                
                StmtIterator si = m.listStatements();
                Statement s = null;
                while(si.hasNext()) {
                    s = si.next();
                    System.out.println(s);                
                }
                
            }
            
            if (opcion.equalsIgnoreCase("correr") || opcion.equalsIgnoreCase("")){
                
                archivos= new String[numArchivos];
                
                for (int arch=0; arch<numArchivos;arch++)
                    archivos[arch]="reglas"+arch+".rules";
                                            
                leeOntologia(m,"ontologia.owl");
                
                
                /*int numFase=10;
                
                for (int arch=0; arch<numArchivos;arch++){
                    leeReglasCorrer(m,archivos[arch]);                    
                }
                  */
                                                                
                OntologyAccess.setNameSpace(urlspace);
                OntologyAccess.setModel(m);
                
                OntologyAccess.prepareOntology();
                
                motor= new Engine();
                
                EscogerJuegos ventanaEscoger = new EscogerJuegos();
                try {
                    URL url = new URL("https://www.google.com.pe/intl/en_ALL/images/srpr/logo11w.png");
                     BufferedImage image = ImageIO.read(url);
                } catch (IOException e) {
                    e.printStackTrace();
                    Configuracion.offline = true;
                    JOptionPane.showMessageDialog(ventanaEscoger, "No hay conexión a internet, no se podrán mostrar las imágenes");
                }
                ventanaEscoger.setVisible(true);
                /*BufferedReader buffer=new BufferedReader(new InputStreamReader(System.in));
                
                System.out.println("Ingrese los juegos que ha jugado:");
                
                while (true){
                    String juegoJugado="";
                    juegoJugado=buffer.readLine();
                    if (juegoJugado==null || juegoJugado.trim().equals(""))
                        break;
                    motor.ingresarJuegoJugado(juegoJugado);
                }
                
                
                System.out.println("Ingrese los juegos que ha comprado:");
                
                while (true){
                    String juegoComprado="";
                    juegoComprado=buffer.readLine();
                    if (juegoComprado==null || juegoComprado.trim().equals(""))
                        break;
                    motor.ingresarJuegoComprado(juegoComprado);
                }
                
                
                System.out.println("Ingrese la consola que desea:");
                
                while (true){
                    String consola="";
                    consola=buffer.readLine();
                    if (consola==null || consola.trim().equals(""))
                        break;
                    motor.ingresarConsola(consola);
                }
                
                
                
                motor.obtenerSugerencias();               
                */
            }
            
            if (opcion.equalsIgnoreCase("red")){
                
                redNeuronal();
                    
                
            }
            
            
            
            System.out.println("Ingrese opcion(correr/salir):");
            opcion=br.readLine();
        }                  
    }
    
    public static void leeOntologia(Model m, String rutaOpcional) throws IOException{
        
        
        if (rutaOpcional==null){
            System.out.print("Ingrese la ruta de la ontología: ");
            rutaOntologia = br.readLine();
        }else
            rutaOntologia = rutaOpcional;

        File f = new File(rutaOntologia);
        if (f.exists() && f.isFile()){ 
            m.read("file:" + rutaOntologia);
                        
            if (Constants.MODO_DEBUG){
                StmtIterator si = m.listStatements();
                Statement s = null;
                while(si.hasNext()) {
                    s = si.next();
                    System.out.println(s);                
                }
                System.out.println("La ontología ha sido leida correctamente");
            }
        }else
            if (Constants.MODO_DEBUG)
                System.out.println("No se encontro el archivo");
        
    }
    
    
    public static void leeReglasCorrer(Model m, String rutaOpcional) throws IOException{
        
        
        
        if (rutaOpcional==null){
            System.out.print("Ingrese la ruta de la reglas: ");
            rutaReglas = br.readLine();
        }else
            rutaReglas = rutaOpcional;


        if (rutaReglas == null)
            return;
        File freglas = new File(rutaReglas);
        if (freglas.exists()) {
            correr(m);
        }else
            System.out.println("No se encontro el archivo");
        
    }

    /*
    public static void addStatement(String statement, Model m){
        String newStatement=
        "[\n" +
            "->\n"+
         statement+"]";
        List<Rule> rules = Rule.parseRules(newStatement);
        GenericRuleReasoner r = new GenericRuleReasoner(rules);
        InfModel infmodel = ModelFactory.createInfModel(r, m);
        m.add(infmodel.getDeductionsModel());
    }
    */
    
    public static void agregarStatement(String recurso, String propiedad, String nodo, Model m){
        
        Resource recurso1 = ResourceFactory.createResource(recurso);
                
                
        Property propiedad1= ResourceFactory.createProperty(propiedad );
                                               
        Resource recurso2 = ResourceFactory.createResource(nodo);
        
        Statement s = ResourceFactory.createStatement(recurso1, propiedad1, recurso2);
                
       //[http://www.semanticweb.org/adrian/ontologies/2014/3/untitled-ontology-4#Bioshock2, http://www.semanticweb.org/adrian/ontologies/2014/3/untitled-ontology-4#NombreJuego, "Bioshock2"]
        
        System.out.println( s );
                
        m.add(s);
        
    }
    
    public static void correr(Model m){
        
        List<Rule> rules = Rule.rulesFromURL("file:" + rutaReglas);
        GenericRuleReasoner r = new GenericRuleReasoner(rules);
        r.setOWLTranslation(true);           
        r.setTransitiveClosureCaching(true);
        Resource conf = m.createResource();
        conf.addProperty(ReasonerVocabulary.PROPruleMode,"forwardRETE");
        InfModel infmodel = ModelFactory.createInfModel(r, m);
        infmodel.prepare();
        m.add(infmodel.getDeductionsModel());
        //addStatement("print('hola')",m);        
    }
    
    public static void reglaDesdeString(Model m, String reglas){
        List<Rule> rules = Rule.parseRules(reglas);
        GenericRuleReasoner r = new GenericRuleReasoner(rules);
        r.setOWLTranslation(true);           
        r.setTransitiveClosureCaching(true);
        Resource conf = m.createResource();
        conf.addProperty(ReasonerVocabulary.PROPruleMode,"forwardRETE");
        InfModel infmodel = ModelFactory.createInfModel(r, m);
        m.add(infmodel.getDeductionsModel());
    }
    
    public static String crearReglaFase(int numFase){
        String regla = 
                "[reglaFase"+numFase+":\n"+
                "-> "+
                "(fase numero "+numFase+")"+
                "]";
        return regla;
    }
    
    
    
    public static void assertFase(Model m,int numFase){
        String reglaFase = crearReglaFase(numFase);
        reglaDesdeString(m,reglaFase);
    }
    
    public static void redNeuronal(){
        
        double n1=2;
        double n2=5;
        double n3=3;
        
        double peso1=50;
        double peso2=50;
        double peso3=50;
        
        int iteraciones=2000000;
        
        double npeso1=peso1;
        double npeso2=peso2;
        double npeso3=peso3;
        
        for(int i=0; i<iteraciones; i++){
            double x= npeso1*n1 + npeso2*n2 + npeso3*n3;
            
            npeso1= npeso1 + (850-x)*n1/350000;
            npeso2= npeso2 + (850-x)*n2/350000;
            npeso3= npeso3 + (850-x)*n3/350000;
            
        }
        
        System.out.println(npeso1);
        System.out.println(npeso2);
        System.out.println(npeso3);

    }
    
}
